﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlTypes;
using Noris.Schedule.Support.Core;

namespace Noris.Schedule.Planning.ProcessData
{
	// SBÍRKA PUBLIC ENUMŮ PLÁNOVACÍHO PROCESU a KONVERZNÍCH METOD

	#region CLASS EnumConvert : konverze enum z/na Value (string/int) a na Text
	/// <summary>
	/// EnumConvert : konverze enum z/na Value (string/int) a na Text
	/// </summary>
	public static class EnumConvert
	{
		/// <summary>
		/// Vrátí boolean hodnotu na základě hodnoty z databáze A/N.
		/// </summary>
		/// <param name="value"></param>
		/// <param name="defValue">Defaultní hodnota, pokud vstupní údaj nebude zadán nebo rozpoznán</param>
		/// <returns></returns>
		internal static bool DbToType(string value, bool defValue)
		{
			if (String.IsNullOrEmpty(value)) return defValue;
			switch (value)
			{
				case "A": return true;
				case "N": return false;
			}
			return defValue;
		}
		/// <summary>
		/// Vrátí databázovou hodnotu "A" / "N" na základě typové hodnoty true / false.
		/// </summary>
		/// <param name="value"></param>
		/// <returns></returns>
		internal static string TypeToDb(bool value)
		{
			return (value ? "A" : "N");
		}
		/// <summary>
		/// Vrátí typovou hodnotu na základě hodnoty z databáze.
		/// </summary>
		/// <param name="value">mfr_mrp_minstock_mode {"N"=Neuvažovat; "A"=Zajistit min. množství k datu prvního návrhu; "C"=Zajistit min. množství po celou dobu plánu}</param>
		/// <param name="defValue">Defaultní hodnota, pokud vstupní údaj nebude zadán nebo rozpoznán</param>
		/// <returns></returns>
		public static MinimumStockQtyMode DbToType(string value, MinimumStockQtyMode defValue)
		{
			if (String.IsNullOrEmpty(value)) return defValue;
			switch (value)
			{
				case "N": return MinimumStockQtyMode.NoMinQty;
				case "A": return MinimumStockQtyMode.OnFirstProposal;
				case "C": return MinimumStockQtyMode.OnPlanBegin;
			}
			return defValue;
		}
		/// <summary>
		/// Vrátí databázovou hodnotu na základě typové hodnoty.
		/// Převede hodnotu MinimumStockQtyMode na hodnotu editačního stylu
		/// mfr_mrp_minstock_mode {"N"=Neuvažovat; "A"=Zajistit min. množství k datu prvního návrhu; "C"=Zajistit min. množství po celou dobu plánu}
		/// </summary>
		/// <param name="value"></param>
		/// <returns></returns>
		internal static string TypeToDb(MinimumStockQtyMode value)
		{
			switch (value)
			{
				case MinimumStockQtyMode.NoMinQty: return "N";
				case MinimumStockQtyMode.OnFirstProposal: return "A";
				case MinimumStockQtyMode.OnPlanBegin: return "C";
			}
			return "";
		}
		/// <summary>
		/// Vrátí typovou hodnotu na základě hodnoty z databáze.
		/// </summary>
		/// <param name="value">[mfr_vyber_t_mod] {1=1: podle plánovaného termínu zahájení; 2=2: podle plánovaného termínu zahájení, a je-li menší než dnes, tak dnes; 3=3: dnešní datum (datum spuštění funkce); 4=4: nejvyšší datum z platných modifikací; 5=5: nejnižší datum z platných modifikací (může jít i do minulosti)}</param>
		/// <param name="defValue">Defaultní hodnota, pokud vstupní údaj nebude zadán nebo rozpoznán</param>
		/// <returns></returns>
		internal static FindAOperationModDateMode DbToType(SqlInt32 value, FindAOperationModDateMode defValue)
		{
			if (value.IsNull) return defValue;
			switch (value.Value)
			{
				case 1: return FindAOperationModDateMode.DateStart;
				case 2: return FindAOperationModDateMode.DateStartOrToday;
				case 3: return FindAOperationModDateMode.Today;
				case 4: return FindAOperationModDateMode.MaxDate;
				case 5: return FindAOperationModDateMode.MinDate;
			}
			return defValue;
		}
		/// <summary>
		/// Vrátí databázovou hodnotu na základě typové hodnoty.
		/// </summary>
		/// <param name="value"></param>
		/// <returns></returns>
		internal static SqlInt32 TypeToDb(FindAOperationModDateMode value)
		{
			switch (value)
			{
				case FindAOperationModDateMode.DateStart: return 1;
				case FindAOperationModDateMode.DateStartOrToday: return 2;
				case FindAOperationModDateMode.Today: return 3;
				case FindAOperationModDateMode.MaxDate: return 4;
				case FindAOperationModDateMode.MinDate: return 5;
			}
			return SqlInt32.Null;
		}
		/// <summary>
		/// Vrátí typovou hodnotu na základě hodnoty z databáze.
		/// </summary>
		/// <param name="value">[mfr_mrp_structure_timing] {1=Na začátek operace; 2=Na začátek času TAC; 3=Na začátek konkrétní výrobní dávky}</param>
		/// <param name="defValue">Defaultní hodnota, pokud vstupní údaj nebude zadán nebo rozpoznán</param>
		/// <returns></returns>
		internal static MrpStructureTimingType DbToType(SqlInt16 value, MrpStructureTimingType defValue)
		{
			if (value.IsNull) return defValue;
			switch (value.Value)
			{
				case 1: return MrpStructureTimingType.ByTask;
				case 2: return MrpStructureTimingType.ByTAC;
				case 3: return MrpStructureTimingType.ByBatch;
			}
			return defValue;
		}
		/// <summary>
		/// Vrátí databázovou hodnotu na základě typové hodnoty.
		/// </summary>
		/// <param name="value"></param>
		/// <returns></returns>
		internal static SqlInt16 TypeToDb(MrpStructureTimingType value)
		{
			switch (value)
			{
				case MrpStructureTimingType.ByTask: return 1;
				case MrpStructureTimingType.ByTAC: return 2;
				case MrpStructureTimingType.ByBatch: return 3;
			}
			return SqlInt16.Null;
		}
		/// <summary>
		/// Vrátí typovou hodnotu na základě hodnoty z databáze.
		/// </summary>
		/// <param name="value">[mfr_process_c_type] {"U"=Neomezené kapacity; "L"=Omezené kapacity; "P"=Dle konkrétní kapacitní jednotky}</param>
		/// <param name="defValue">Defaultní hodnota, pokud vstupní údaj nebude zadán nebo rozpoznán</param>
		/// <returns></returns>
		internal static LimitedCType DbToType(string value, LimitedCType defValue)
		{
			if (String.IsNullOrEmpty(value)) return defValue;
			switch (value)
			{
				case "U": return LimitedCType.Unlimited;
				case "L": return LimitedCType.Limited;
				case "P": return LimitedCType.ByPUCsetting;
			}
			return defValue;
		}
		/// <summary>
		/// Vrátí databázovou hodnotu na základě typové hodnoty.
		/// </summary>
		/// <param name="value"></param>
		/// <returns></returns>
		internal static string TypeToDb(LimitedCType value)
		{
			switch (value)
			{
				case LimitedCType.Unlimited: return "U";
				case LimitedCType.Limited: return "L";
				case LimitedCType.ByPUCsetting: return "P";
			}
			return "";
		}
		/// <summary>
		/// Vrátí typovou hodnotu na základě hodnoty z databáze.
		/// </summary>
        /// <param name="value">[mfr_movetime_term] {"R"=Prostý čas; "K"=Jeden konkrétní kalendář; "P"=Kalendář podle pracoviště operace; "C"=Registrovat do kapacit pracoviště}</param>
		/// <param name="defValue">Defaultní hodnota, pokud vstupní údaj nebude zadán nebo rozpoznán</param>
		/// <returns></returns>
        internal static AllocMode DbToType(string value, AllocMode defValue)
		{
			if (String.IsNullOrEmpty(value)) return defValue;
			switch (value)
			{
                case "R": return AllocMode.CalculatePlainTime;
                case "K": return AllocMode.CalculateTimeByCalendar;
                case "P": return AllocMode.CalculateTimeByWorkplace;
                case "C": return AllocMode.RegisterIntoUsedPlanUnits;
			}
			return defValue;
		}
		/// <summary>
		/// Vrátí databázovou hodnotu na základě typové hodnoty.
		/// </summary>
		/// <param name="value"></param>
		/// <returns></returns>
        internal static string TypeToDb(AllocMode value)
		{
			switch (value)
			{
                case AllocMode.CalculatePlainTime: return "R";
                case AllocMode.CalculateTimeByCalendar: return "K";
                case AllocMode.CalculateTimeByWorkplace: return "P";
                case AllocMode.RegisterIntoUsedPlanUnits: return "C";
            }
			return "";
		}
        /// <summary>
        /// Vrátí typovou hodnotu na základě hodnoty z databáze.
        /// </summary>
        /// <param name="value">[mfr_movetime_term] {"R"=Prostý čas; "K"=Jeden konkrétní kalendář; "P"=Kalendář podle pracoviště operace; "C"=Registrovat do kapacit pracoviště}</param>
        /// <param name="defValue">Defaultní hodnota, pokud vstupní údaj nebude zadán nebo rozpoznán</param>
        /// <returns></returns>
        internal static MfrOperationPlanning DbToType(string value, MfrOperationPlanning defValue)
        {
            if (String.IsNullOrEmpty(value)) return defValue;
            switch (value)
            {
                case "A": return MfrOperationPlanning.PlanByProcess;
                case "N": return MfrOperationPlanning.NoPlanTime;
                case "C": return MfrOperationPlanning.PlanOnlyFlowTime;
            }
            return defValue;
        }
        /// <summary>
        /// Vrátí databázovou hodnotu na základě typové hodnoty.
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        internal static string TypeToDb(MfrOperationPlanning value)
        {
            switch (value)
            {
                case MfrOperationPlanning.PlanByProcess: return "A";
                case MfrOperationPlanning.NoPlanTime: return "N";
                case MfrOperationPlanning.PlanOnlyFlowTime: return "C";
            }
            return "";
        }
		/// <summary>
		/// Vrátí typovou hodnotu na základě hodnoty z databáze.
		/// </summary>
		/// <param name="value">[mfr_cplplan_unit_mode] {0=Neplánovat; 1=Plánovat nejvhodnější, střídat podle potřeby; 2=Plánovat nejvhodnější, pokud možno nestřídat; 3=Plánovat nejvhodnější, nestřídat, čekat na uvolnění původní; 4=Plánovat nejvhodnější, nestřídat jednotky nikdy}</param>
		/// <param name="defValue">Defaultní hodnota, pokud vstupní údaj nebude zadán nebo rozpoznán</param>
		/// <returns></returns>
		internal static SourceFixUnitMode DbToType(SqlInt16 value, SourceFixUnitMode defValue)
		{
			if (value.IsNull) return defValue;
			switch (value.Value)
			{
				case 0: return SourceFixUnitMode.NoPlanning;
				case 1: return SourceFixUnitMode.AnyOfAvailable;
				case 2: return SourceFixUnitMode.Conservative;
				case 3: return SourceFixUnitMode.ConstantTemporal;
				case 4: return SourceFixUnitMode.ConstantPermanent;
			}
			return defValue;
		}
		/// <summary>
		/// Vrátí databázovou hodnotu na základě typové hodnoty.
		/// </summary>
		/// <param name="value"></param>
		/// <returns></returns>
		internal static SqlInt16 TypeToDb(SourceFixUnitMode value)
		{
			switch (value)
			{
				case SourceFixUnitMode.NoPlanning: return 0;
				case SourceFixUnitMode.AnyOfAvailable: return 1;
				case SourceFixUnitMode.Conservative: return 2;
				case SourceFixUnitMode.ConstantTemporal: return 3;
				case SourceFixUnitMode.ConstantPermanent: return 4;
			}
			return SqlInt16.Null;
		}
		/// <summary>
		/// Vrátí typovou hodnotu na základě hodnoty z databáze.
		/// </summary>
		/// <param name="value">[mfr_cplplan_unit_mode] {0=Neplánovat; 1=Plánovat nejvhodnější, střídat podle potřeby; 2=Plánovat nejvhodnější, pokud možno nestřídat; 3=Plánovat nejvhodnější, nestřídat, čekat na uvolnění původní; 4=Plánovat nejvhodnější, nestřídat jednotky nikdy}</param>
		/// <param name="defValue">Defaultní hodnota, pokud vstupní údaj nebude zadán nebo rozpoznán</param>
		/// <returns></returns>
		internal static TFictiousItemQtyToParallelMode DbToType(short value, TFictiousItemQtyToParallelMode defValue)
		{
			if (value == (short)0) return defValue;
			switch (value)
			{
				case 1: return TFictiousItemQtyToParallelMode.NoChange;
				case 2: return TFictiousItemQtyToParallelMode.SetQtyToParallelCount;
				case 3: return TFictiousItemQtyToParallelMode.SetRatioToParallelCount;
			}
			return defValue;
		}
		/// <summary>
		/// Vrátí databázovou hodnotu na základě typové hodnoty.
		/// </summary>
		/// <param name="value"></param>
		/// <returns></returns>
		internal static short TypeToDb(TFictiousItemQtyToParallelMode value)
		{
			switch (value)
			{
				case TFictiousItemQtyToParallelMode.NoChange: return 1;
				case TFictiousItemQtyToParallelMode.SetQtyToParallelCount: return 2;
				case TFictiousItemQtyToParallelMode.SetRatioToParallelCount: return 3;
			}
			return (short)0;
		}
		/// <summary>
		/// Vrátí typovou hodnotu na základě hodnoty z databáze.
		/// </summary>
		/// <param name="value"></param>
		/// <param name="defValue">Defaultní hodnota, pokud vstupní údaj nebude zadán nebo rozpoznán</param>
		/// <returns></returns>
		internal static PlanWhDocOrderType DbToType(string value, PlanWhDocOrderType defValue)
		{
			if (String.IsNullOrEmpty(value)) return defValue;
			switch (value)
			{
				case "A": return PlanWhDocOrderType.OrderToProduction;
				case "N": return PlanWhDocOrderType.OrderStandard;
				case "C": return PlanWhDocOrderType.OrderConfirmed;
			}
			return defValue;
		}
		/// <summary>
		/// Vrátí databázovou hodnotu na základě typové hodnoty.
		/// </summary>
		/// <param name="value"></param>
		/// <returns></returns>
		internal static string TypeToDb(PlanWhDocOrderType value)
		{
			switch (value)
			{
				case PlanWhDocOrderType.OrderToProduction: return "A";
				case PlanWhDocOrderType.OrderStandard: return "N";
				case PlanWhDocOrderType.OrderConfirmed: return "C";
			}
			return null;
		}
		/// <summary>
		/// Vrátí typovou hodnotu na základě hodnoty z databáze.
		/// </summary>
		/// <param name="valueBP">Hodnota z databáze = režim načítání obchodního plánu
		/// [mrp_plan_nolink] {"n"=Nevyužívat párovací funkce Plán - Realita; "p"=Použít existující výsledky funkce Plán - Realita; "r"=Spustit funkci Plán - Realita a použít výsledky}</param>
		/// <param name="valueAN">Hodnota z databáze = načítat položky obchodního plánu: přepínač A/N</param>
		/// <param name="defValue">Defaultní hodnota, pokud vstupní údaj nebude zadán nebo rozpoznán</param>
		/// <returns></returns>
        public static MrpBussinesPlanMode DbToType(string valueBP, string valueAN, MrpBussinesPlanMode defValue)
		{
			if (String.IsNullOrEmpty(valueAN)) return defValue;
            if (valueAN != "A")
                return MrpBussinesPlanMode.NotRead;

			if (String.IsNullOrEmpty(valueBP)) return defValue;
			switch (valueBP)
			{
				case "n":
					return MrpBussinesPlanMode.CreateSilentPair;
				case "p":
					return MrpBussinesPlanMode.ReadExistingPair;
				case "r":
					return MrpBussinesPlanMode.CreateNewPair;
			}
			return defValue;
		}
		/// <summary>
		/// Vrátí databázovou hodnotu na základě typové hodnoty.
		/// </summary>
		/// <param name="value"></param>
		/// <returns></returns>
        public static string TypeToDb(MrpBussinesPlanMode value, string defValue)
		{
			switch (value)
			{
				case MrpBussinesPlanMode.ReadExistingPair:
				case MrpBussinesPlanMode.CreateNewPair:
				case MrpBussinesPlanMode.CreateSilentPair:
					return "A";
			}
			return defValue;
		}
		/// <summary>
		/// Vrátí databázovou hodnotu na základě typové hodnoty.
		/// </summary>
		/// <param name="value"></param>
		/// <returns></returns>
        public static string TypeToDb(MrpBussinesPlanMode value, MrpBussinesPlanMode defValue)
		{
			switch (value)
			{
				case MrpBussinesPlanMode.ReadExistingPair:
					return "p";
				case MrpBussinesPlanMode.CreateNewPair:
					return "r";
				case MrpBussinesPlanMode.CreateSilentPair:
					return "n";
			}
			return null;
		}
        /// <summary>
		/// Vrátí typovou hodnotu na základě hodnoty z databáze.
		/// </summary>
		/// <param name="value">
        /// [mfr_plan_date_round_type] {"D"=Minimální; "U"=Maximální; "E"=Zadané v plánu}
		/// </param>
		/// <param name="defValue">Defaultní hodnota, pokud vstupní údaj nebude zadán nebo rozpoznán</param>
		/// <returns></returns>
        public static MrpBussinesPlanDateRoundMode DbToType(string value, MrpBussinesPlanDateRoundMode defValue)
		{
			if (String.IsNullOrEmpty(value)) return defValue;
			switch (value)
			{
                case "U": return MrpBussinesPlanDateRoundMode.Maximum;
                case "D": return MrpBussinesPlanDateRoundMode.Minimum;
                case "E": return MrpBussinesPlanDateRoundMode.Explicit;
			}
			return defValue;
		}
		/// <summary>
		/// Vrátí databázovou hodnotu na základě typové hodnoty.
        /// Převede hodnotu MrpBussinesPlanDateRoundMode na hodnotu editačního stylu
        /// [mfr_plan_date_round_type] {"D"=Minimální; "U"=Maximální; "E"=Zadané v plánu}
		/// </summary>
		/// <param name="value"></param>
		/// <returns></returns>
        public static string TypeToDb(MrpBussinesPlanDateRoundMode value)
		{
			switch (value)
			{
                case MrpBussinesPlanDateRoundMode.Maximum: return "U";
                case MrpBussinesPlanDateRoundMode.Minimum: return "D";
                case MrpBussinesPlanDateRoundMode.Explicit: return "E";
			}
			return null;
		}
		/// <summary>
		/// Vrátí typovou hodnotu na základě hodnoty z databáze.
		/// </summary>
		/// <param name="value">
		/// mfr_proposal_action {"n"=Žádná akce; "v"=Vytvořit VP nebo objednávku; "z"=Zrušit VP nebo objednávku; "m"=Snížit množství; "t"=Upravit termín; "k"=Snížit množství a upravit termín}
		/// </param>
		/// <param name="defValue">Defaultní hodnota, pokud vstupní údaj nebude zadán nebo rozpoznán</param>
		/// <returns></returns>
		public static PlanSAxisSuggestedActionType DbToType(string value, PlanSAxisSuggestedActionType defValue)
		{
			if (String.IsNullOrEmpty(value)) return defValue;
			switch (value)
			{
				case "n": return PlanSAxisSuggestedActionType.NoAction;
				case "v": return PlanSAxisSuggestedActionType.IssueNewRecord;
				case "z": return PlanSAxisSuggestedActionType.Delete;
				case "m": return PlanSAxisSuggestedActionType.ChangeQty;
				case "t": return PlanSAxisSuggestedActionType.ChangeDate;
				case "k": return PlanSAxisSuggestedActionType.ChangeDateAndQty;
			}
			return defValue;
		}
		/// <summary>
		/// Vrátí databázovou hodnotu na základě typové hodnoty.
		/// Převede hodnotu PlanSAxisSuggestedActionType na hodnotu editačního stylu
		/// mfr_proposal_action {"n"=Žádná akce; "v"=Vytvořit VP nebo objednávku; "z"=Zrušit VP nebo objednávku; "m"=Snížit množství; "t"=Upravit termín; "k"=Snížit množství a upravit termín}
		/// </summary>
		/// <param name="value"></param>
		/// <returns></returns>
        public static string TypeToDb(PlanSAxisSuggestedActionType value)
		{
			switch (value)
			{
				case PlanSAxisSuggestedActionType.NoAction: return "n";
				case PlanSAxisSuggestedActionType.IssueNewRecord: return "v";
				case PlanSAxisSuggestedActionType.Delete: return "z";
				case PlanSAxisSuggestedActionType.ChangeQty: return "m";
				case PlanSAxisSuggestedActionType.ChangeDate: return "t";
				case PlanSAxisSuggestedActionType.ChangeDateAndQty: return "k";
			}
			return null;
		}
        /// <summary>
		/// Vrátí typovou hodnotu na základě hodnoty z databáze.
		/// </summary>
		/// <param name="value">
		/// mfr_timing_type {"S"=Dle stavu skladu; "T"=Dle průběžných dob; "F"=Dle dostupných kapacit}
		/// </param>
		/// <param name="defValue">Defaultní hodnota, pokud vstupní údaj nebude zadán nebo rozpoznán</param>
		/// <returns></returns>
		public static MrpOperationTimingType DbToType(string value, MrpOperationTimingType defValue)
		{
			if (String.IsNullOrEmpty(value)) return defValue;
			switch (value)
			{
				case "S": return MrpOperationTimingType.StockLevelTime;
				case "T": return MrpOperationTimingType.LeadFeedTime;
				case "F": return MrpOperationTimingType.CapacityLevelTime;
			}
			return defValue;
		}
		/// <summary>
		/// Vrátí databázovou hodnotu na základě typové hodnoty.
		/// Převede hodnotu MrpOperationTimingType na hodnotu editačního stylu
		/// mfr_timing_type {"S"=Dle stavu skladu; "T"=Dle průběžných dob; "F"=Dle dostupných kapacit}
		/// </summary>
		/// <param name="value"></param>
		/// <returns></returns>
        public static string TypeToDb(MrpOperationTimingType value)
		{
			switch (value)
			{
				case MrpOperationTimingType.StockLevelTime: return "s";
                case MrpOperationTimingType.LeadFeedTime: return "T";
                case MrpOperationTimingType.CapacityLevelTime: return "F";
			}
			return null;
		}
        /// <summary>
		/// Vrátí typovou hodnotu na základě hodnoty z databáze.
		/// </summary>
		/// <param name="value">mfr_planning_state</param>
		/// <param name="defValue">Defaultní hodnota, pokud vstupní údaj nebude zadán nebo rozpoznán</param>
		/// <returns></returns>
        public static PlanningProcessState DbToType(SqlInt32 value, PlanningProcessState defValue)
		{
			if (value.IsNull) return defValue;
            if (Enum.IsDefined(typeof(PlanningProcessState), value.Value))
                return (PlanningProcessState)(value.Value);
            return defValue;
		}
		/// <summary>
		/// Vrátí databázovou hodnotu na základě typové hodnoty.
        /// Převede hodnotu PlanningProcessState na hodnotu editačního stylu mfr_planning_state.
		/// </summary>
		/// <param name="value"></param>
		/// <returns></returns>
        public static SqlInt32 TypeToDb(PlanningProcessState value)
		{
            return new SqlInt32((int)value);
		}
        /// <summary>
        /// Vrátí uživatelskou hodnotu (čitelný text) na základě typové hodnoty.
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static string TypeToUser(PlanningProcessState value)
        {
            SqlInt32 dbValue = TypeToDb(value);
            if (dbValue.IsNull) return ((int)value).ToString() + ": " + value.ToString();
            return Noris.Schedule.Support.Green.Repository.EditStyles.GetDispVal("mfr_planning_state", dbValue.Value, value.ToString());
        }
    }
	#endregion
	#region ENUM DataFunctionType (typy datových akcí); PlanningProcessDataState (stav procesu v datech jedné verze)
	/// <summary>
	/// DataFunctionType : typy datových akcí. Hodnotu koresponduje s property 
	/// </summary>
	public enum DataFunctionType
	{
		/// <summary>
		/// Žádná funkce
		/// </summary>
		None = 1,
		/// <summary>
		/// Funkce pro přípravu dat (načtení číselníků), okruh dat, která jsou platná pro všechny verze dat jedné databáze
		/// </summary>
		DataPrepare,
		/// <summary>
		/// Vyžádaný refresh permanentních dat = přenačtení poptávek, STPV dokumentace, stavu VP, atd atd tad.
		/// </summary>
		DataRefresh,
		/// <summary>
		/// Funkce pro načtení dat plánu, data která jsou závislá na verzi dat
		/// </summary>
		DataLoad,
		/// <summary>
		/// Funkce pro uložení dat aktuální verze dat
		/// </summary>
		DataSave,
		/// <summary>
		/// Funkce pro zobrazení okna parametrů procesu
		/// </summary>
		PlanningConfig,
		/// <summary>
		/// Funkce pro vytvoření nového plánu, všechny položky
		/// </summary>
		PlanCreateNew,
		/// <summary>
		/// Funkce pro dopředné přeplánování všech nefixovaných položek
		/// </summary>
		PlanForwardAll,
		/// <summary>
		/// Funkce pro přeplánování položek, které nejsou fixované
		/// </summary>
		PlanUnfixed
	}
	#endregion
	#region ENUM PlanSAxisChangeType, PlanSAxisPlanningState, PlanSAxisResourceType, PlanSAxisRoundDatePlan, PlanSAxisAttributes
	/// <summary>
	/// Druhy změn skladové zásoby
	/// </summary>
    [EditStyleName("mfr_axis_change_type")]
    public enum PlanSAxisChangeType
	{
		/// <summary>1: Toto není změna</summary>
        [EditStyleDisplayValue("Není změna")]
		NotChange = 1,
        /// <summary>2: Zvýšení zásoby příjmem z existující objednávky od dodavatele</summary>
        [EditStyleDisplayValue("Příjem z existující objednávky od dodavatele")]
        IncrementByRealSupplierOrder = 2,
        /// <summary>3: Zvýšení zásoby příjmem z návrhu objednávky od dodavatele</summary>
        [EditStyleDisplayValue("Příjem z návrhu objednávky od dodavatele")]
        IncrementByPlanSupplierOrder = 3,
		/// <summary>4: Zvýšení zásoby příjmem z existujícího výrobního příkazu</summary>
        [EditStyleDisplayValue("Příjem z existujícího výrobního příkazu")]
        IncrementByRealProductOrder = 4,
		/// <summary>5: Zvýšení zásoby příjmem z návrhu výrobního příkazu</summary>
        [EditStyleDisplayValue("Příjem z návrhu výrobního příkazu")]
        IncrementByPlanProductOrder = 5,
		/// <summary>6: Zvýšení zásoby příjmem z vedlejšího produktu existujícího výrobního příkazu, použitelný materiál/polotovar</summary>
        [EditStyleDisplayValue("Příjem vedlejšího produktu z existujícího výrobního příkazu, použitelný materiál/polotovar")]
        IncrementByRealByProductSuitable = 6,
		/// <summary>7: Zvýšení zásoby příjmem z vedlejšího produktu návrhu výrobního příkazu, použitelný materiál/polotovar</summary>
        [EditStyleDisplayValue("Příjem vedlejšího produktu z návrhu výrobního příkazu, použitelný materiál/polotovar")]
        IncrementByPlanByProductSuitable = 7,
		/// <summary>8: Zvýšení zásoby příjmem z vedlejšího produktu existujícího výrobního příkazu, nepoužitelný materiál/polotovar</summary>
        [EditStyleDisplayValue("Příjem vedlejšího produktu z existujícího výrobního příkazu, nepoužitelný materiál/polotovar")]
        IncrementByRealByProductDissonant = 8,
		/// <summary>9: Zvýšení zásoby příjmem z vedlejšího produktu návrhu výrobního příkazu, nepoužitelný materiál/polotovar</summary>
        [EditStyleDisplayValue("Příjem vedlejšího produktu z návrhu výrobního příkazu, nepoužitelný materiál/polotovar")]
        IncrementByPlanByProductDissonant = 9,
        /// <summary>10: Zvýšení návrhem na příjem (obecný, který se má specifikovat na hodnotu: IncrementByPlanProductOrder nebo IncrementByPlanOrder nebo IncrementByPlanStockTransfer)</summary>
        [EditStyleDisplayValue("Návrh na příjem")]
        IncrementByProposalReceipt = 10,
		/// <summary>11: Snížení zásoby výdejem do reálné poptávky</summary>
        [EditStyleDisplayValue("Výdej do reálné poptávky")]
        DecrementByRealEnquiry = 11,
		/// <summary>12: Snížení zásoby výdejem do plánované poptávky (obchodní plán)</summary>
        [EditStyleDisplayValue("Výdej do poptávky obchodního plánu")]
        DecrementByPlanEnquiry = 12,
		/// <summary>13: Snížení zásoby výdejem do komponenty reálného výrobního příkazu</summary>
        [EditStyleDisplayValue("Výdej komponenty do reálného výrobního příkazu")]
        DecrementByRealComponent = 13,
        /// <summary>14: Snížení zásoby výdejem do komponenty plánovaného výrobního příkazu</summary>
        [EditStyleDisplayValue("Výdej komponenty do reálného plánovaného příkazu")]
        DecrementByPlanComponent = 14,
		/// <summary>15: Snížení zásoby návrhem na výdej do jiného skladu</summary>
        [EditStyleDisplayValue("Návrh na výdej do jiného skladu")]
        DecrementByProposalRequisition = 15,
		/// <summary>16: Příjem ze skladové objednávky, zajištěné vlastní výrobou</summary>
        [EditStyleDisplayValue("Příjem ze skladové objednávky, zajištěné vlastní výrobou")]
        IncrementByOrderProduction = 16,
        /// <summary>17: Příjem z návrhu převodu z jiného skladu</summary>
        [EditStyleDisplayValue("Příjem z návrhu převodu z jiného skladu")]
        IncrementByPlanStockTransfer = 17

	}
	/// <summary>
	/// Důvody vzniku záznamu, při kumulaci se sčítají (jde o Flag).
	/// </summary>
	[Flags]
	public enum PlanSAxisOriginReason
	{
		/// <summary>
		/// 0: Není žádný důvod vzniku
		/// </summary>
        [EditStyleDisplayValue("Není žádný důvod vzniku")]
        NoReason = 0,
		/// <summary>
		/// 1: Reálná poptávka / objednávka
		/// </summary>
        [EditStyleDisplayValue("Reálná poptávka / objednávka")]
        RealRequest = 1,
		/// <summary>
		/// 2: Poptávka obchodního plánu
		/// </summary>
        [EditStyleDisplayValue("Poptávka obchodního plánu")]
        PlanRequest = 2,
		/// <summary>
		/// 4: Zajištění minimální zásoby
		/// </summary>
        [EditStyleDisplayValue("Zajištění minimální zásoby")]
        MinimumStock = 4
	}
	/// <summary>
	/// Režim zajištění minimální zásoby
	/// </summary>
	public enum MinimumStockQtyMode
	{
		/// <summary>
		/// Nezajišťovat
		/// </summary>
        [EditStyleDisplayValue("Nezajišťovat")]
        NoMinQty = 1,
		/// <summary>
        /// Zajistit minimální množství k datu prvního návrhu na zajištění ("A")
		/// </summary>
        [EditStyleDisplayValue("Zajistit minimální množství k datu prvního návrhu na zajištění")]
        OnFirstProposal = 'A',
		/// <summary>
        /// Zajistit minimální množství po celou dobu plánu ("C")
		/// </summary>
        [EditStyleDisplayValue("Zajistit minimální množství po celou dobu plánu")]
        OnPlanBegin = 'C'
	}
	/// <summary>
	/// Stav záznamu na materiálové ose z hlediska plánování. Ovlivňuje i procesy rekalkulace skladové karty.
	/// </summary>
	public enum PlanSAxisPlanningState
	{
		/// <summary>
		/// Záznam neexistuje. Využívají odvozené třídy, pokud nejsou navázané na materiálovou osu.
		/// </summary>
		NotExists = 1,
		/// <summary>
		/// Záznam je aktivní. Počítá se s ním. Má vliv na skladové zásoby. Dosud není definitivně zaplánován.
		/// </summary>
		Active,
		/// <summary>
		/// Záznam je pozastaven. Nebude se plánovat. Má vliv na skladové zásoby.
		/// </summary>
		Suspended,
		/// <summary>
		/// Záznam je skrytý. Nemá vliv na skladové zásoby, jako by na skladové kartě nebyl. 
		/// Skladová karta sice počítá jeho ResultQty, ale nepřebírá jej do FlowQty pro výpočty časově následujících stavů.
		/// </summary>
		Hidden,
		/// <summary>
		/// Záznam je hotový. Je zaplánovaný. Má vliv na skladové zásoby. Nebude se již plánovat.
		/// </summary>
		Finished
	}
	/// <summary>
	/// Stav záznamu osy S z hlediska termínování kapacit
	/// </summary>
	public enum PlanSAxisSchedulingState
	{
		/// <summary>
		/// Pro tento záznam se nebudou termínovat kapacity.
		/// </summary>
		None = 1,
		/// <summary>
		/// Kapacity se mají termínovat, ale ještě se s tím nezačalo.
		/// </summary>
		NotScheduled,
		/// <summary>
		/// Kapacity se mají termínovat, záznam je v seznamu k termínování (termínování probíhá dávkově za více záznamů).
		/// </summary>
		Prepared,
		/// <summary>
		/// Kapacity již jsou termínované.
		/// </summary>
		Scheduled
	}
	/// <summary>
	/// Způsob získání potřebné zásoby pro konkrétní záznam osy S (ze skladu, od dodavatele, vlastní výrobou)
	/// </summary>
	public enum PlanSAxisAcquirementType
	{
		/// <summary>
		/// Není třeba získávat (např. tento řádek sám popisuje příjem)
		/// </summary>
		Needless = 1,
		/// <summary>
		/// Ze skladu, dodavatelem je některý náš sklad
		/// </summary>
		FromStock,
		/// <summary>
		/// Od dodavatele, dodavatelem je vnější organizace
		/// </summary>
		FromSupplier,
		/// <summary>
		/// Výroba, vyrobíme si potřebné množství sami
		/// </summary>
		Manufacturing,
		/// <summary>
		/// Nelze určit, ale je potřeba získat = chyba
		/// </summary>
		BadDefinition
	}
	/// <summary>
	/// Způsob zaokrouhlení datumu pohybu na položce obchodního plánu
	/// </summary>
	public enum PlanSAxisRoundDatePlan
	{
		/// <summary>
		/// Převzít explicitně
		/// </summary>
		Explicit = 1,
		/// <summary>
		/// Zaokrouhlit na prvního v měsíci
		/// </summary>
		ToFirstDayInMonth,
		/// <summary>
		/// Zaokrouhlit na posledního v měsíci
		/// </summary>
		ToLastDayInMonth
	}
	/// <summary>
	/// Příznaky stavu na záznamu osy S
	/// </summary>
	[Flags]
	public enum PlanSAxisAttributes
	{
		/// <summary>Prázdné atributy, 0</summary>
		Empty = 0,
		/// <summary><para>marker1: (0='p', 1='D') 1=Datum pohybu je převzato z atributu "Datum položky"  /  0="Datum plán"</para><para>POZOR: pro výdej do komponenty (=atribut IsProductOrderStructure) je zde nastaveno 'k' !!!</para></summary>
		DateFromPlan = 1,
		/// <summary>marker1: (0=???, 1='k') 1=Jde o komponentu VP  /  0=podle atributu DateFromPlan (na pozici markeru 1 je více stavů)</summary>
        IsProductOrderStructure = DateFromPlan << 1,
		/// <summary>marker4: (0=' ', 1='d') 1=Výrobní příkaz, který nemá ani jednu operaci (vygenerovanou výrobní dokumentaci)  /  0=má operace</summary>
		ProductOrderWithNoOperation = IsProductOrderStructure << 1,
		/// <summary>marker5: (0=' ', 1='b') 1=Položka pochází z poptávky obchodního plánu  /  0=jde o běžnou reálnou poptávku)</summary>
		BussinesPlanEnquiry = ProductOrderWithNoOperation << 1,
		/// <summary>Návrh z důvodu zajištění minimální zásoby</summary>
        ProposalForMinimalQty = BussinesPlanEnquiry << 1,
        /// <summary>Alternativa byla dohledána náhradním algoritmem (s nejmenší velikostí dávky)</summary>
        AlternativeFoundForMinBatchQty = ProposalForMinimalQty << 1,
        /// <summary>Alternativa nebyla dohledána ani náhradním algoritmem - záznam je nekonzistetní, bez T modifikace</summary>
        AlternativeNotFound = AlternativeFoundForMinBatchQty << 1
	}
	/// <summary>
	/// Doporučená akce na záznamu osy S
	/// </summary>
	public enum PlanSAxisSuggestedActionType
	{
		/// <summary>
		/// Žádný návrh, null (na rozdíl od "n"=Žádná akce)
		/// </summary>
        [EditStyleDisplayValue("")]
        None = 1,
		/// <summary>
		/// Není třeba žádná akce, "n"=Žádná akce (na rozdíl od null)
		/// </summary>
        [EditStyleDisplayValue("Žádná akce")]
        NoAction = 'n',
		/// <summary>
		/// Založit nový (výrobní příkaz nebo objednávku), "v"=Vytvořit VP nebo objednávku
		/// </summary>
        [EditStyleDisplayValue("Vytvořit VP nebo objednávku")]
        IssueNewRecord = 'v',
		/// <summary>
		/// Smazat podkladový záznam, není pro něj důvod, "z"=Zrušit VP nebo objednávku
		/// </summary>
        [EditStyleDisplayValue("Zrušit VP nebo objednávku")]
        Delete = 'z',
		/// <summary>
		/// Změnit množství na podkladovém záznamu, "m"=Snížit množství
		/// </summary>
        [EditStyleDisplayValue("Snížit množství")]
        ChangeQty = 'm',
		/// <summary>
		/// Změnit datum na podkladovém záznamu, "t"=Upravit termín
		/// </summary>
        [EditStyleDisplayValue("Upravit termín")]
        ChangeDate = 't',
		/// <summary>
		/// Změnit datum i množství na podkladovém záznamu, "k"=Snížit množství a upravit termín
		/// </summary>
        [EditStyleDisplayValue("Snížit množství a upravit termín")]
        ChangeDateAndQty = 'k'
	}
	/// <summary>
	/// Druh objednávky ze skladové položky: Objednávka běžná, potvrzená, objednávka do výroby
	/// </summary>
	public enum PlanWhDocOrderType
	{
		/// <summary>
		/// Toto není objednávka
		/// </summary>
		None = 1,
		/// <summary>
		/// Standardní objednávka k dodavateli
		/// </summary>
		OrderStandard,
		/// <summary>
		/// Potvrzená objednávka k dodavateli
		/// </summary>
		OrderConfirmed,
		/// <summary>
		/// Objednávka do výroby: zajistit výrobu (komponenty, kapacitu).
		/// Akceptuje se pouze tehdy, když je možno na daném skladě danou věc vyrobit.
		/// </summary>
		OrderToProduction
	}
	#endregion
	#region ENUM OperationPhase : typy fází
	/// <summary>
	/// Časy fází
	/// </summary>
	[EditStyleName("mfr_operation_phase")]
    public enum OperationPhase : int
	{
		/// <summary>Žádná fáze, nedefinováno, příznak konce v řetězu výrobních fází (vráceno jak GetNext po poslední operaci)</summary>
		None = 0,
		/// <summary>MOVE_TIME: fyzicky první fáze. Čas na přesun rozpracované výroby na dané pracoviště. Následuje TBC.</summary>
        [EditStyleDisplayValue("Move time")]
		MoveTime = 1,
		/// <summary>TBC: následuje po MOVE_TIME. Čas na přípravu pro výrobu. Následuje TAC.</summary>
        [EditStyleDisplayValue("Čas TBC")]
        TBC = 2,
		/// <summary>TAC: následuje po TBC. Čas na výrobu jedné výrobní jednotky (v množství unit_count). Následuje TEC.</summary>
        [EditStyleDisplayValue("Čas TAC")]
        TAC = 3,
		/// <summary>TEC: následuje po TAC. Čas na úklid po výrobě. Poté je hotovo (None).</summary>
        [EditStyleDisplayValue("Čas TEC")]
        TEC = 4
	}
	#endregion
	#region ENUM potřebné pro registraci kapacit
	/// <summary>
	/// Druh kapacity, která je registrována (Real, Plan, Simulation).
    /// Je navázaný na editační styl "Kategorie požadavku"
	/// </summary>
    [EditStyleName("Kategorie požadavku")]
    public enum CapacityUsageType
	{
		/// <summary>Neurčeno (použije se jako Blank hodnota)</summary>
        None = 0,
		/// <summary>Reálná kapacita, daný výrobním příkazem</summary>
		Real = 1,
		/// <summary>Plánovaná kapacita, daná plánem výroby (dosud nezahájená výroba)</summary>
		Plan = 2,
		/// <summary>Simulovaná kapacita, daná externím požadavkem. Ukládá se do databáze.</summary>
		Simulation = 3,
		/// <summary>Kalkulovaná kapacita, jen náhled, neukládá se do databáze, ukládá se do pomocného stavu ve stavech kapacit (capacity_used_calc).</summary>
		Calculation = 4,
	}
	/// <summary>
	/// Druh omezení kapacit pro konkrétní úkol a plánovací jednotku (Neomezené kapacity, Omezené kapacity, Podle KPJ)
	/// </summary>
	[EditStyleName("mfr_limited_c_type")]
    public enum LimitedCType : int
	{
		/// <summary>(nedefinováno)</summary>
		NotDefined = 0,
		/// <summary>U = Unlimited = Neomezené stavy kapacit</summary>
		Unlimited = 'U',
		/// <summary>L = Limited = Omezené stavy kapacit</summary>
		Limited = 'L',
		/// <summary>P = PlanUnitC = Podle plánovací jednotky (může se vyskytnout v parametru funkce, nesmí se vyskytnout u konkrétního úkolu)</summary>
		[EditStyleDisplayValue("Podle plánovací jednotky")]
        ByPUCsetting = 'P',
	}
	/// <summary>
	/// Režim fixování kapacitních jednotek pro konkrétní task.
	/// Některé operace / typy zdrojů mohou vyžadovat, aby se práce provedla na jedné kapacitní jednotce
	/// (např. nepřehazovat výrobu den co den na jiný stroj), 
	/// ale jiné případy to umožní (každou směnu může pracovat jiný soustružník).
	/// </summary>
	public enum SourceFixUnitMode
	{
		/// <summary>
		/// Tento zdroj se nemá plánovat do kapacit
		/// </summary>
		NoPlanning = 1,
		/// <summary>
		/// Jakýkoli z dostupných.
		/// Pro každý časový úsek můžeme kdykoliv vzít libovolnou použitelnou kapacitní jednotku, 
		/// bez ohledu použité jednotky v předchozím časovém úseku
		/// </summary>
		AnyOfAvailable,
		/// <summary>
		/// Konzervativní přístup.
		/// Pokud začnu práci na jedné kapacitní jednotce, a ta je k dispozici i v příštím čase, snažím se na této jednotce pokračovat.
		/// Pokud jednotka není k dispozici, přejdu na jinou, podle pravidel vhodnosti.
		/// </summary>
		Conservative,
		/// <summary>
		/// Konstantní přístup s omezenou trpělivostí.
		/// Pokud začnu práci na jedné kapacitní jednotce, tak to na ní dokončím, 
		/// i když bych měl na ni čekat a přitom se mi nabízely jiné disponibilní.
		/// Pokud se ale nedočkám do určité doby (specifikováno v parametrech), 
		/// pak umožním přejít na jinou kapacitní jednotku.
		/// </summary>
		ConstantTemporal,
		/// <summary>
		/// Konstantní přístup s neomezenou trpělivostí.
		/// Pokud začnu práci na jedné kapacitní jednotce, tak to na ní dokončím, 
		/// i když bych měl na ni čekat nekonečně dlouho (timeout systému), i kdyby se mi přitom nabízely jiné disponibilní jednotky.
		/// </summary>
		ConstantPermanent
	}
	/// <summary>
	/// Stav registrace kapacitního úkolu.
	/// Jde o souhrn příznaků (Flags).
	/// </summary>
	[Flags]
	public enum CapacityRegisterState
	{
		/// <summary>
		/// Kapacitní úkol je naplněn, ale dosud neprošel registrací kapacit (anebo byl odregistrován)
		/// </summary>
		Initialized = 0,
		/// <summary>
		/// Kapacitní úkol prošel registrací. Pokud neobsahuje další příznaky, je registrován bez problémů.
		/// </summary>
		Registered = 1,
		/// <summary>
		/// Kapacitní úkol je zaregistrován do kapacitního systému, 
		/// ale ne zcela - chybí kapacity.
		/// Tento stav může nastat v situaci, kdy je požadována taková kombinace kapacitních zdrojů,
		/// která nemá nikdy žádný společný časový úsek (zdroje jsou k dispozici na střídačku).
		/// Pak je provedena registrace s vynecháním některého kapacitního zdroje.
		/// </summary>
		WithMissingCapacity = 2,
		/// <summary>
		/// Kapacitní úkol je zaregistrován do kapacitního systému, 
		/// ale čas jeho začátku (WorkBegin) je nižší, než čas InitialDate 
		/// = úkol se se nejspíš nestihne dokončit do času požadovaného konce.
		/// </summary>
		BeforeInitialDate = 4
	}
	/// <summary>
	/// Způsob alokace času pro zvláštní případy
	/// </summary>
	public enum AllocMode
	{
		/// <summary>
		/// Vypočítat fyzický čas bez ohledu na definované kalendáře.
		/// Jde o prostý denní čas (24 hodin denně, 7 dní v týdnu).
		/// Při použití na čas TA nebude počítáno s žádným paralelismem, čas pojede v jedné Pipes.
		/// Default hodnota.
		/// </summary>
		CalculatePlainTime = 1,
		/// <summary>
		/// Vypočítat čas podle kalendáře plánovací jednotky pracoviště.
		/// Při použití na čas TA nebude počítáno s žádným paralelismem, čas pojede v jedné Pipes.
		/// </summary>
		CalculateTimeByWorkplace,
		/// <summary>
		/// Vypočítat čas podle specifikovaného kalendáře.
		/// Kalendář se specifikuje do jiného pole, přiměřeného dle názvu.
		/// Při použití na čas TA nebude počítáno s žádným paralelismem, čas pojede v jedné Pipes.
		/// </summary>
		CalculateTimeByCalendar,
		/// <summary>
		/// Registrovat do disponibilních kapacit do všech zúčastněných kapacitních plánovacích jednotek.
		/// Toto je základní stav pro fáze TBC, TAC, TEC.
		/// </summary>
		RegisterIntoUsedPlanUnits
	}
	/// <summary>
	/// Kategorie kapacitního zdroje.
	/// Hodnota (int) tohoto enumu vyjadřuje jeho prioritu při hledání důležitějšího zdroje.
	/// </summary>
	[EditStyleName("mfr_capacity_category")]
    public enum CapacitySourceCategory : int
	{
		/// <summary>
		/// Nedefinovaná kategorie.
		/// </summary>
		NotDefined = 0,
		/// <summary>
		/// Pracoviště, druh stroje
		/// </summary>
		Workplace = 1,
		/// <summary>
		/// Profese, druh pracovníka
		/// </summary>
		Profession = 2,
		/// <summary>
		/// Přípravek, nářadí, něco co je potřeba pro výrobu ale výrobou se nespotřebovává ("katalyzátor")
		/// </summary>
		Resource = 3,
		/// <summary>
		/// Všechny kategorie kapacitních zdrojů. Používá se při sumarizaci kapacit.
		/// </summary>
		AllCategory = 4
	}
    /// <summary>
    /// Režim termínování operací - podle reálných kapacit, nebo podle STPV, nebo podle stavu skladu.
    /// Viz atribut PlanningControlCls.OperationTiming.
    /// Odpovídá editačnímu stylu mfr_timing_type.
    /// </summary>
    public enum MrpOperationTimingType
    {
        /// <summary>
        /// Neurčeno
        /// </summary>
        NotDefined = 0,
        /// <summary>
        /// [S] Pouze podle lhůt na stavu skladu (čas operace = 0, časy komponent jsou dány pouze lhůtami na stavu skladu: dodávka + rezerva, na návrhu na příjem)
        /// Obchází kapacitní plánování.
        /// </summary>
        StockLevelTime,
        /// <summary>
        /// [T] Podle času operace v STPV/VP + kalendář, bez ohledu na kapacitní jednotky.
        /// Obchází kapacitní plánování.
        /// </summary>
        LeadFeedTime,
        /// <summary>
        /// [F] Podle reálných časů z kapacitního plánování.
        /// Neobchází kapacitní plánování.
        /// </summary>
        CapacityLevelTime
    }
    /// <summary>
	/// Režim termínování komponent v závislosti na časech operace
	/// </summary>
	public enum MrpStructureTimingType
	{
		/// <summary>
		/// Podle celé operace. 
		/// Defaultní nastavení, odpovídá původnímu chování.
		/// Požadavek na komponentu je v čase MoveTime.Begin,
		/// příjem vedlejšího produktu je v čase TEC.End
		/// </summary>
		ByTask = 1,
		/// <summary>
		/// Podle času TAC dané operace.
		/// Požadavek na komponentu je v čase TAC.Begin,
		/// příjem vedlejšího produktu je v čase TAC.End
		/// </summary>
		ByTAC,
		/// <summary>
		/// Podle času jednotlivých dávek dané operace.
		/// Požadavek na komponentu je v čase TAC, konkrétní výrobní dávka, Begin.
		/// Příjem vedlejšího produktu je v čase TAC, konkrétní výrobní dávka, End.
		/// Pokud operace nemá výrobní dávky, pak je časování podle časů celé TAC.
		/// </summary>
		ByBatch
	}
	/// <summary>
	/// Režimy načítání položek obchodního plánu
	/// </summary>
	public enum MrpBussinesPlanMode
	{
		/// <summary>
		/// "Init=NE": Nenačítat položky obchodního plánu
		/// </summary>
		NotRead = 1,
		/// <summary>
		/// "n": Vytvořit nové skryté párování, v režimu "bez párování" = postaru (bez masky a bez třídy Párování),
		/// ale s využitím metod Párování.
		/// </summary>
		CreateSilentPair,
		/// <summary>
		/// "p": Načíst existující položky párování plánu a reality
		/// </summary>
		ReadExistingPair,
		/// <summary>
		/// "r": Vytvořit nové položky párování plánu a reality, a ty potom načíst
		/// </summary>
		CreateNewPair
	}
    /// <summary>
    /// Druh zaokrouhlování datumu u položky obchodního plánu.
    /// Datum plán uvažovat [mfr_plan_date_round_type] {"D"=Minimální; "U"=Maximální; "E"=Zadané v plánu}</para><para>Db: lcs.plan_c_version_hdr.mrp_plan_date_round_type
    /// </summary>
    public enum MrpBussinesPlanDateRoundMode
    {
        /// <summary>
        /// "D": Minimální
        /// </summary>
        Minimum = 1,
        /// <summary>
        /// "U": Maximální
        /// </summary>
        Maximum,
        /// <summary>
        /// "E": Zadané v plánu
        /// </summary>
        Explicit
    }
    /// <summary>
	/// Druh fixace kapacity, odpovída editačnímu stylu "mfr_oper_fixed"
	/// </summary>
	public enum MfrFixedOperationType
	{
		/// <summary>0 = Nefixovaná</summary>
		NotFixed = 0,
		/// <summary>1 = Fixovaná</summary>
		Fixed = 1
	}
    /// <summary>
    /// Druh zpracování operace v plánování (plánovat Ano / Ne / Jen čas bez kapacit).
    /// </summary>
    public enum MfrOperationPlanning
    {
        /// <summary>A = Plánovat tak, jak je nastaveno v parametrech procesu</summary>
        PlanByProcess = 0,
        /// <summary>N = Neplánovat (čas = 0), ale komponenty navázané na operaci zaplánovat</summary>
        NoPlanTime,
        /// <summary>C = Plánovat jen průběžný čas operace bez zaplánování do kapacit</summary>
        PlanOnlyFlowTime
    }
	#endregion
	#region ENUM TDocumentType, TOperationUnitCountVariability, TResourceUnitQty
	/// <summary>
	/// Typy technologických dat
	/// </summary>
	public enum TDocumentType
	{
		/// <summary>
		/// Neurčeno
		/// </summary>
		None = 0,
		/// <summary>
		/// Technologické plány vývojové (VTPV)
		/// </summary>
		PlanPrepared,
		/// <summary>
		/// Technologické plány schválené (STPV)
		/// </summary>
		PlanApproved,
		/// <summary>
		/// Reálná dokumentace běžící výroby (VP)
		/// </summary>
		Production
	}
	/// <summary>
	/// Vliv množství fiktivního dílce z kusovníku nadřízeného dílce na počet paralelních průchodů v operacích fiktivního dílce
	/// </summary>
	public enum TFictiousItemQtyToParallelMode
	{
		/// <summary>
		/// Počet paralelních průchodů se nezmění
		/// </summary>
		NoChange = 1,
		/// <summary>
		/// Počet paralelních průchodů se nastaví podle množství fiktivního dílce, jakékoli číslo
		/// </summary>
		SetQtyToParallelCount,
		/// <summary>
		/// Počet paralelních průchodů se nastaví podle množství fiktivního dílce, pouze počet menší než 1
		/// </summary>
		SetRatioToParallelCount
	}
	/// <summary>
	/// Typ dělitelnosti operace z hlediska jeho UnitCount
	/// </summary>
	public enum TOperationUnitCountVariability
	{
		/// <summary>
		/// Počet UnitCount, deklarovaný na operaci, je nezměnitelný. Vždy se vyrobí daný počet kusů v jednotce času TAC.
		/// Příklad: stříhací forma, v níž je 10 otvorů pro vystřihnutí 10 ks najednou. Formu nelze rozebrat.
		/// Defaultní v Norisu.
		/// </summary>
		Fixed = 1,
		/// <summary>
		/// Počet UnitCount, deklarovaný na operaci, je možno změnit, 
		/// a vyjadřuje počet ks vyrobených na plně využitém stroji s koeficientem UnitCountCoefficient = 100%.
		/// V případě potřeby je možno vyrábět více nebo méně jednotek než daný UnitCount.
		/// </summary>
		Variable
	}
	/// <summary>
	/// Typ násobnosti množství (Qty) obecného zdroje kapacit (např. forma) na výrobu jedné dávky na operaci (UnitCount)
	/// </summary>
	public enum TResourceUnitQty
	{
		/// <summary>
		/// Množství zdroje (IResourceData.Qty) platí pro jeden celý průchod (Pass).
		/// Počet UnitCount je vyroben jedním chodem stroje, a tento počet nelze operativně změnit.
		/// Například mnohočetná forma na jednochodové stříhání plechových výstřižků.
		/// </summary>
		QtyToUnitCount,
		/// <summary>
		/// Množství zdroje (IResourceData.Qty) platí pro jeden výrobek, 
		/// takže pro počet (IOperationData : IOperationTime.UnitCount) je zapotřebí alokovat patřičný násobek kapacitních zdrojů.
		/// Typicky jde o jednu formu, která vyrobí jeden výrobek, ale do jednoho stroje (lisu) jich lze vložit více vedle sebe.
		/// To, zda lze počet UnitCount změnit, je dáno atributem (IOperationData.UnitCountVariable == Variable).
		/// Na každou vyráběnou jednotku je nutno alokovat IResourceData.Qty zdrojů, na jeden průchod tedy IResourceData.Qty * IOperationTime.UnitCount
		/// </summary>
		QtyToOneProduct
	}
	#endregion
	#region ENUM FindAOperationModDateMode (režim hledání T modifikace); FindAOperationModApprovalMode (schválený proces)
	/// <summary>
	/// FindAOperationModMode : režim vyhledání nejvhodnější T modifikace v seznamu existujících.
	/// Jde o programový ekvivalent editačního stylu mfr_vyber_t_mod (předvolba režimu hledání T-modifikace)
	/// </summary>
	public enum FindAOperationModDateMode : int
	{	// Odpovídá editačnímu stylu mfr_vyber_t_mod:
		/// <summary>1: podle plánovaného termínu zahájení</summary>
		DateStart = 1,
		/// <summary>2: podle plánovaného termínu zahájení, a je-li menší než dnes, tak dnes</summary>
		DateStartOrToday = 2,
		/// <summary>3: dnešní datum (datum spuštění funkce)</summary>
		Today = 3,
		/// <summary>4: nejvyšší datum z platných modifikací</summary>
		MaxDate = 4,
		/// <summary>5: nejnižší datum z platných modifikací (může jít i do minulosti)</summary>
		MinDate = 5
	}
	/// <summary>
	/// FindAOperationModMode : režim vyhledání nejvhodnější T modifikace v seznamu existujících.
	/// Jde o programový ekvivalent editačního stylu mfr_vyber_t_mod (předvolba režimu hledání T-modifikace)
	/// </summary>
	public enum FindAOperationModApprovalMode : int
	{	// Odpovídá editačnímu stylu mfr_vyber_t_mod:
		/// <summary>Bez ohledu na schválení</summary>
		Unlimited = 1,
		/// <summary>Schváleno pro plánování</summary>
		ApprovalToPlanningProcess,
		/// <summary>Schváleno pro výrobu</summary>
		ApprovalToProduction
	}
	#endregion
	#region ENUM vlastního plánovacího procesu (PlanningProcessThreadMode, PlanningResultSeverityType, PlanningResultCircumstanceType, PlanningLoadCapacityMode)
	/// <summary>
	/// Režim threadingu plánovacího procesu
	/// </summary>
	public enum PlanningProcessThreadMode
	{
		/// <summary>
		/// Výhradně jednovláknový proces
		/// </summary>
		SingleThread,
		/// <summary>
		/// Pokud je k dispozici více procesorů / jáder, pak multithread. Na singlecore = jeden thread.
		/// </summary>
		MultiThreadOnMultiCore,
		/// <summary>
		/// Vždy multithread, i na jednojádru.
		/// </summary>
		MultiThread
	}
	/// <summary>
	/// Závažnost události
	/// </summary>
	public enum PlanningResultSeverityType
	{
		/// <summary>Jen informace</summary>
		Info = 1,
		/// <summary>Varování, upozornění na nestandardní situaci</summary>
		Warning,
		/// <summary>Chyba na straně uživatele</summary>
		UserError,
		/// <summary>Chyba na straně aplikace</summary>
		SystemError
	}
	/// <summary>
	/// Příležitost, kdy k události došlo
	/// </summary>
	public enum PlanningResultCircumstanceType
	{
		/// <summary></summary>
		System = 1,
		/// <summary>Detekce programové nekonečné smyčky</summary>
		ProgramEndlessLooping,
		/// <summary>Nekonzistence indexů v paměti procesu</summary>
		IndexSeek,
		/// <summary>Obecný odkaz na neexistující položku číselníku</summary>
		DeadRelation,
        /// <summary>Nalezli jsme položku, která se nemá plánovat.</summary>
        MaterialNotPlanning,
        /// <summary>Skladový doklad obsahuje údaje, které nejsou vzájemně konzistentní nebo nenavazují na číselníky</summary>
		WarehouseDocumentNotConsistent,
		/// <summary>Výrobní příkaz obsahuje údaje, které nejsou vzájemně konzistentní nebo nenavazují na číselníky</summary>
		ProductOrderNotConsistent,
		/// <summary>Generování návrhů na příjem narazilo na položku, pro kterou nelze určit zdroj (dodavatel, sklad, výrobek)</summary>
		MaterialResourcingNotSupplier,
        /// <summary>Generování návrhů na příjem narazilo na položku, kde je chybně určen dodavatel</summary>
		MaterialResourcingBadSupplier,
		/// <summary>Generování návrhů na příjem narazilo na položku, kde je chybně určen sklad</summary>
		MaterialResourcingBadStock,
		/// <summary>Generování návrhů na příjem narazilo na položku, kde je chybně určena plánovací jednotka S</summary>
		MaterialResourcingBadPlanUnitS,
		/// <summary>Zaplánování výrobního příkazu - nekonzistentní podklady</summary>
		PlanningProductOrderBadData,
		/// <summary>Nenalezena vhodná technologie výroby (dílec, T modifikace, atd)</summary>
		TechnologyNotFound,
		/// <summary>Chyba zacyklení fiktivních dílců</summary>
		TechnologyFictiousItemCycle,
		/// <summary>Chybná data pro scheduling konkrétní položky výroby</summary>
		SchedulingBadParams,
		/// <summary>Chybná data pro scheduling kapacit konkrétní položky výroby</summary>
		SchedulingCapacityBadParams,
		/// <summary>Při registraci kapacit v režimu kordinace dávek nelze úspěšně registrovat návaznou operaci.</summary>
		CapacityRegisterBatchShift,
		/// <summary>Načítání stavů kapacit</summary>
		LoadCapacity,
		/// <summary></summary>
		Other
	}
	/// <summary>
	/// Načítání dat z databáze, režim načítání dsponibilní kapacity
	/// </summary>
	public enum PlanningLoadCapacityMode
	{
		/// <summary>
		/// Disponibilní kapacitu načíst z databáze (i kdyby byla nekonzistentnní se součtem práce ve stavu kapacit)
		/// </summary>
		LoadDisponibleCapacity,
		/// <summary>
		/// Disponibilní kapacitu přepočítat (načíst kaapacitu totální, a za každý jednotlivý pracovní úsek odečíst jeho kapacitu)
		/// </summary>
		RecalcCapacityByWork
	}
	/// <summary>
	/// Předpis pro metodu, která má najít data v paměti, pro situaci kdy data v paměti nejsou
	/// </summary>
	public enum NotFindMode
	{
		/// <summary>
		/// Pokud data nejsou v paměti, vrať null
		/// </summary>
		Null,
		/// <summary>
		/// Pokud data nejsou v paměti, vrať prázdný objekt (new)
		/// </summary>
		Empty,
		/// <summary>
		/// Pokud data nejsou v paměti, podívej se do databáze.
		/// Pokud nejsou ani v databázi, vrať null.
		/// </summary>
		GetFromDbNull,
		/// <summary>
		/// Pokud data nejsou v paměti, podívej se do databáze.
		/// Pokud nejsou ani v databázi, vrať prázdný objekt (new)
		/// </summary>
		GetFromDbEmpty
	}
    /// <summary>
    /// Stav plánovacího procesu, odpovídá editačnímu stylu Greenu: mfr_planning_state, jeho obraz je uložen v lcs.plan_c_version_hdr.planning_state, 
    /// pomáhá řešit konflikty při plánování více uživatelů najednou.
    /// Změny stavu řeší dispečer PlanningControlCls.SetProcessState(state), volá odpovídající metodu v partial třídě PlanCVersionHdrCls.
    /// </summary>
    public enum PlanningProcessState
    {
        /// <summary>
        /// 0: nic
        /// </summary>
        None = 0,
        /// <summary>
        /// 1: Neexistuje (plán byl smazán)
        /// </summary>
        NotExist = 1,
        /// <summary>
        /// 2: Plán je otevřený (někdo si otevřel plánovací tabuli, ale ještě neprovedl aktivní změnu dat). Stále má tu možnost.
        /// </summary>
        PreEdit = 2,
        /// <summary>
        /// 3: Upravuje se (někdo začal vytvářet nový plán, nebo stávající plán začal upravovat).
        /// Před přechodem do tohoto stavu je třeba zajistit, aby nikdo jiný nebyl aktuálně ve stavu NowEditing ani SavingData.
        /// </summary>
        NowEditing = 3,
        /// <summary>
        /// 4: Ukládání dat (právě probíhá zápis do databáze).
        /// Po ukončení zápisu se přechází do stavu AfterSave, po něm pak do Save nebo do NowEditing.
        /// </summary>
        SavingData = 4,
        /// <summary>
        /// 5: Uložen a otevřen.
        /// Někdo uložil data, ale stále k nim má přístup a může je začít editovat. Je to stav v podstatě odpovídající stavu PreEdit.
        /// </summary>
        AfterSave = 5,
        /// <summary>
        /// 6: Uložený.
        /// Data jsou v databázi, nikdo se nechystá je měnit.
        /// </summary>
        Save = 6
    }
	#endregion
	#region ENUM pro zadávání interaktivních změn
	/// <summary>
	/// Volba režimu fixace tasků.
	/// Jednotlivé požadavky lze sčítat.
	/// </summary>
	[Flags]
	public enum InteractiveFixSetting
	{
		/// <summary>
		/// Žádná změna
		/// </summary>
		NoChange = 0,
		/// <summary>
		/// Zrušit fixaci
		/// </summary>
		Unfix = 0x01,
		/// <summary>
		/// Nastavit fixaci
		/// </summary>
		Fix = 0x02,
		/// <summary>
		/// Pouze pro vybranou operaci
		/// </summary>
		SelectedTask = 0x10,
		/// <summary>
		/// Pro všechny operace jednoho dílce
		/// </summary>
		SelectedFinal = 0x20
	}
	#endregion
	#region ENUM pro zadávání požadavku na linkování
	/// <summary>
	/// Enum pro zadávání požadavku na linkování
	/// </summary>
	public enum InteractiveLinkSetting
	{
		/// <summary>
		/// Default, nic neudělá.
		/// </summary>
		NoChange,
		/// <summary>
		/// Všechny zadané operace (na které ukazují elementy) rozvázat (odlinkovat)
		/// </summary>
		UnLink,
		/// <summary>
		/// Všechny zadané operace (na které ukazují elementy) svázat do nové skupiny.
		/// Pokud některý z elementů nyní patří do jiné skupiny, pak se z ní odváže.
		/// Pokud tedy označím například dvě operace, které jsou dosud členem oddělených skupin,
		/// pak touto volbou se z těch skupin vyjmou a spojí se spolu do nové skupiny.
		/// </summary>
		LinkToNewSeparate,
		/// <summary>
		/// Všechny zadané operace (na které ukazují elementy) svázat do skupiny.
		/// Pokud některé elementy (operace) patří do jiné existující skupiny, 
		/// pak ze všech těchto skupin vytvoří velkou skupinu 
		/// (vybere první existující skupinu, a do ní naváže všechny vybrané i další jejich nevybrané členy).
		/// Například ze dvou skupin takto vytvoří její souhrn (sjednocení).
		/// </summary>
		LinkToCollective
	}
	#endregion
	#region ENUM CapacityDefinitionType : DRUH DEFINICE KAPACITY (směna, svátek, přídavek, ...)
	/// <summary>
	/// Typ definice kapacity.
	/// </summary>
	public enum CapacityDefinitionType
	{
		/// <summary>
		/// Běžná opakovaná pracovní směna.
		/// </summary>
		DayWorkShift = 1,
		/// <summary>
		/// Přídavek (+) nebo snížení (-) kapacity běžné denní směny. 
		/// Hodnota kapacity v této položce definice se přičte ke kapacitě v běžné denní směně.
		/// </summary>
		AddToWorkShift,
		/// <summary>
		/// Výměna pracovní směny: namísto dat zadaných v pracovní směně (+AddToWorkShift) platí pro zde uvedený čas tato definice.
		/// Je tak možno nastavit kapacitu = 0.
		/// </summary>
		ExchangeOfWorkShift,
		/// <summary>
		/// Pevný svátek, opakující se v daný den každý rok (až do případné změny společenského řádu).
		/// </summary>
		YearlyHoliday,
		/// <summary>
		/// Pohyblivý svátek, je platný pouze v daném roce.
		/// </summary>
		MovableHoliday,
		/// <summary>
		/// Zrušený svátek. 
		/// Má význam, že pokud vychází svátek do pracovního týdne, 
		/// lze tímto záznamem svátek "odstranit" a chovat se k pracovní směně jako k běžnému dni.
		/// </summary>
		DisableHoliday
	}
	#endregion
}
